1. Technical Field
The present disclosure relates to detection and handling of data errors and, more specifically, to detection of data errors in tag arrays.
2. Description of Related Art
Data errors in arrays (“soft errors”) are occurring increasingly in response to shrinking feature sizes and lower operating voltage. Typically, data can be protected by error detection and error correction codes. Error detection and correction of the error maintains data integrity. Specifically, an error detection code can detect when an error has occurred, and indicate data corruption, e.g., to handle with a higher level mechanism. A common error detection code is the known parity code. Error correction codes can be used to reconstruct the data prior to the error occurring. Typically, error correction codes also are used to detect an error. A common error correction code is the known ECC code.
For parity error handling, a stream of input data is broken up into blocks of bits and the number of 1 bit is counted. Then, for example, a parity bit is set if the number of one bits is odd and cleared if the number of 1 bit is even. If tested blocks overlap, the parity bits can be used to isolate the error and correct it if the error affects a single bit.
Systems for parity error handling are typically high overhead, high logic complexity solutions, or introduce additional delay, where any logic delay slows down the entire system performance.
Tag arrays, e.g., 103, are typically used in cache systems to select between multiple elements in an equivalence set, i.e., the set of lines with a common cache index. Tag arrays are particularly vulnerable to data errors, as their outputs are usually time critical and used for data selection circuits (multiplexers, e.g., 105 in FIG. 1). Furthermore, data selection logic may pose a requirement on tag match logic (e.g., 106-107 in FIG. 1) to produce one-hot encoded select signals, i.e., wherein only one input is selected by a bit vector wherein each bit corresponds to a single input to the selection circuit, and wherein exactly one bit is set to a logic “1” value to indicate the selection of the corresponding data source.
Tag match may naturally result in one-hot outputs, because the same tag cannot be present twice in a given equivalence set, as each data element can be stored at most once (i.e., “synonyms”, duplicate tags in an equivalence set, are commonly not allowed). Alas, a data error can cause two tags to match contemporaneously, leading to logic and potentially electric issues in the data selection circuit. This may require enforcing one hot encoding, where only one selection bit is asserted, using additional logic inserted in a critical path, i.e., a path where any logic delay slows down the entire system performance.
In the past, some designs have operated with unprotected tag arrays, as tag arrays were sufficiently small to not pose a significant risk. However, with smaller feature sizes, the frequency of soft error rates increases, and this problem must be addressed for all arrays.
Parity checking (e.g., see 104 in FIG. 1) is often in a critical path, or recovery is difficult if speculatively assumed that no errors have occurred because of a need to undo all state changes based on speculative assumption that there is no parity error. A number of solutions have been introduced.
In one system, on any parity error in any array, there is a signal to the recovery-unit which initiates in the test logic to clear out all the arrays.
Given that not all processor core designs implement a recovery-unit, this is not a general solution.
Specifically, this solution is not applicable to designs without a recovery unit.
Also, stopping an Instruction Fetch Address Register (IFAR) 101, clearing the arrays 102-103, and restarting is typically performed using additional logic and degrades performance in the presence of soft errors, which are increasing in frequency with the small feature sizes (see FIG. 1).
Therefore, a need exists for a method to efficiently control a data selection circuits in response to tag arrays lookups and tag match logic, while avoiding synonyms introduced by data errors in a tag array.